
package main.old.new_2023.last.month_9;


import java.util.*;

/**
 * @Description: todo 2605. 从两个数字数组里生成最小数字
 * 给你两个只包含 1 到 9 之间数字的数组 nums1 和 nums2 ，每个数组中的元素 互不相同 ，请你返回 最小 的数字，两个数组都 至少 包含这个数字的某个数位。
 *
 * todo 1456. 定长子串中元音的最大数目
 * 给你字符串 s 和整数 k 。
 * 请返回字符串 s 中长度为 k 的单个子字符串中可能包含的最大元音字母数。
 * 英文中的 元音字母 为（a, e, i, o, u）。
 *
 * todo 151. 反转字符串中的单词
 * 给你一个字符串 s ，请你反转字符串中 单词 的顺序。
 * 单词 是由非空格字符组成的字符串。s 中使用至少一个空格将字符串中的 单词 分隔开。
 * 返回 单词 顺序颠倒且 单词 之间用单个空格连接的结果字符串。
 * 注意：输入字符串 s中可能会存在前导空格、尾随空格或者单词间的多个空格。返回的结果字符串中，单词间应当仅用单个空格分隔，且不包含任何额外的空格。
 *
 * todo 1679. K 和数对的最大数目
 * 给你一个整数数组 nums 和一个整数 k 。
 * 每一步操作中，你需要从数组中选出和为 k 的两个整数，并将它们移出数组。
 * 返回你可以对数组执行的最大操作数。
 *
 * @Author: Take-off
 * @Date: 1:00 PM 2023/6/
 * @Param:
 * @return:
 **/
public class Solution0905 {

    //和数对的最大数目
    public int maxOperations(int[] nums, int k) {
        int sum = 0;
        //两个map，一个存出现次数，一个存结果
        Map<Integer, Integer> numCount = new HashMap<>();
        Set<Integer> numResult = new HashSet<>();
        for (int num:nums){
            numCount.put(num,numCount.getOrDefault(num,0) +1);
        }
        for (Integer num:numCount.keySet()){
            if (!numResult.contains(num)){
                int temp = k - num;
                if (temp == num){
                    sum  += numCount.get(num)/2;
                }else {
                    sum  +=  Math.min(numCount.get(num),numCount.getOrDefault(temp,0));
                }
                numResult.add(num);
                numResult.add(temp);
            }
        }
        return sum;
    }

    //反转字符串中的单词
    public String reverseWords(String s) {
        //双指针
        char[] chars = s.toCharArray();
        int length = chars.length;
        Stack<String> stack = new Stack<>();
        for (int i = 0; i< length; i++){
            if (chars[i] != ' '){
                for (int j = i; j< length; j++){
                    if (chars[j] == ' '){
                        //i - j 为一个单词
                        stack.push(s.substring(i, j));
                        i = j;
                        break;
                    }
                    if (j == length-1){
                        //i - j 为一个单词
                        stack.push(s.substring(i));
                        i = j;
                        break;
                    }
                }
            }
        }
        StringBuilder sb = new StringBuilder();
        while (!stack.isEmpty()){
            sb.append(stack.pop()).append(" ");
        }
        if (sb.length() >0){
            return sb.substring(0,sb.length()-1);
        }
        return "";

    }

    private static List<Character> yuan = Arrays.asList('a','e','i','o','u');
    //定长子串中元音的最大数目
    public int maxVowels(String s, int k) {
        int result = 0;
        int sum = 0;
        //滑动窗口双指针
        int length = s.length();
        int right = k;
        if (k > length){
            right = length;
        }
        char[] chars = s.toCharArray();
        for (int i=0;i<right;i++){
            if (yuan.contains(chars[i])){
                sum++;
            }
        }
        result = sum;
        for (int i = right;i<length;i++){
            if (yuan.contains(chars[i])){
                sum++;
            }
            if (yuan.contains(chars[i-k])){
                sum--;
            }
            result = Math.max(result,sum);
        }
        return result;
    }

    //从两个数字数组里生成最小数字
    public int minNumber(int[] nums1, int[] nums2) {
        HashSet<Integer> nums = new HashSet<>();
        int minA = 9;
        int minB = 9;
        int count = Integer.MAX_VALUE;
        for (int i:nums1 ){
            minA = Math.min(i,minA);
            nums.add(i);
        }
        for (int i:nums2){
            minB = Math.min(i,minB);
            if (nums.contains(i)){
                count = Math.min(i,count);
            }
        }
        if (count<10){
            return count;
        }
        return Math.min(minA*10 + minB,minB*10 + minA);

    }
}
